home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1994 November / macformat-018.iso / Comms Spectacular / MacTCP / TurboTCP / TurboTCP.source / CTCPStream.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-10  |  9.6 KB  |  290 lines  |  [TEXT/KAHL]
  1. /*
  2. ** CTCPStream.h
  3. **
  4. **    TurboTCP support library
  5. **    TCP stream class
  6. **
  7. **    Copyright © 1993, FrostByte Design / Eric Scouten
  8. **
  9. */
  10.  
  11.  
  12. #pragma once
  13.  
  14. #ifndef TurboTCPHeaders
  15.     #include <CCollaborator.h>
  16.     #include <CCluster.h>
  17.     #include <MacTCPCommonTypes.h>
  18.     #include <TCPPB.h>
  19.     #include "TurboTCP.const.h"
  20. #endif
  21.  
  22. CLASS CTCPAsyncCall;
  23.  
  24.  
  25. // reason codes for TCP stream notifications
  26.  
  27. enum {
  28.     tcpStreamClosed = 1,            // connection closed            info = NULL
  29.     tcpStreamClosing,                // connection is closing        info = TRUE if remote host cause close
  30.     tcpStreamDataArrived,            // data arrived                info = (DataArrivedInfo *)
  31.     tcpStreamDataSent,                // data was sent            info = (wdsEntry *)
  32.     tcpStreamICMP,                // ICMP notification            info = (struct ICMPReport *)
  33.     tcpStreamOpened,                // connection opened            info = NULL
  34.     tcpStreamOpenFailed,            // couldn’t open session        info = (OSErr) the result code
  35.     tcpStreamSendFailed,            // couldn’t send data        info = (SendFailedInfo *)
  36.     tcpStreamTCPError,                // TCP error occurred        info = (TCPErrorInfo *)
  37.     tcpStreamTerminated,            // session terminated        info = (TerminatedInfo *)
  38.     tcpStreamTimeout,                // timeout occurred            info = NULL
  39.     tcpStreamUnexpectedData,        // unexpected data arrived    info = NULL
  40.     tcpStreamUrgentBegin,            // urgent data begins        info = NULL
  41.  
  42.     tcpStreamLastChange = tcpStreamUrgentBegin
  43. };
  44.  
  45.  
  46. // type definitions for TCP stream notifications to dependent objects
  47.  
  48. typedef struct DataArrivedInfo {
  49.     Ptr        theData;
  50.     b_16        theDataSize;
  51.     Boolean    isUrgent;
  52. } DataArrivedInfo;
  53.  
  54. typedef struct SendFailedInfo {
  55.     wdsEntry *WDSPtr;
  56.     OSErr    theResultCode;
  57. } SendFailedInfo;
  58.  
  59. typedef struct TCPErrorInfo {
  60.     OSErr    theResultCode;
  61.     short    theCsCode;            // the MacTCP operation which failed
  62. } TCPErrorInfo;
  63.  
  64. typedef struct TerminatedInfo {
  65.     b_16        terminReason;
  66.     Boolean    aboutToDispose;        // TRUE if stream will be disposed
  67. } TerminatedInfo;
  68.  
  69.  
  70. // connection state codes for TCP Status call
  71.  
  72. enum {
  73.     strClosed = 0,
  74.     strListen = 2,
  75.     strSYNReceived = 4,
  76.     strSYNSent = 6,
  77.     strEstablished = 8,
  78.     strFINWait1 = 10,
  79.     strFINWait2 = 12,
  80.     strCloseWait = 14,
  81.     strClosing = 16,
  82.     strLastAck = 18,
  83.     strTimeWait = 20
  84. };
  85.  
  86.  
  87. // miscellaneous constants
  88.  
  89. #define autoReceiveMax        32                    // maximum # of entries in RDS
  90. #define IPOptionStringSize    40
  91. typedef char IPOptionString [IPOptionStringSize];
  92.  
  93.  
  94. /*______________________________________________________________________
  95. **
  96. ** CTCPStream
  97. **
  98. **    This class implements a stream for MacTCP. A TCP stream supports one connection at
  99. **    a time; but a connection may be closed and another connection opened without releasing
  100. **    the stream.
  101. **
  102. **    IMPORTANT: This object is a descendant of CCollaborator. Your application class should
  103. **    make itself a dependent of this object so that it may receive notification of resolver
  104. **    call completions.
  105. **
  106. **    All MacTCP commands are originated through this class. (See the methods labelled
  107. **    “basic user TCP calls” below.) These methods originate asynchronous calls to the
  108. **    MacTCP driver by creating CTCPAsyncCall objects to correspond with each call. When
  109. **    the call is completed, notification is passed back to the caller by means of the
  110. **    BroadcastChange mechanism.
  111. **
  112. **    This object also receives notification of asynchronous events related to the stream and
  113. **    passes these notifications to its dependents through the BroadcastChange mechanism.
  114. **    (See the description of the asynchronous notification routine [ASR] in the MacTCP
  115. **    manuals.)
  116. **
  117. **    Your application class need not be concerned with interrupt-level constraints on
  118. **    memory management. The CTCPStream object queues notifications received at interrupt
  119. **    level and the CTCPDriver schedules their processing at the next event loop.
  120. **
  121. */
  122.  
  123. class CTCPStream : public CCollaborator {
  124.  
  125. public:
  126.     ip_addr            itsRemoteIP;                // remote host’s IP address
  127.     b_16                itsRemotePort;                // remote host’s TCP port
  128.     ip_addr            itsLocalIP;                // local host’s IP address
  129.     b_16                itsLocalPort;                // local host’s TCP port
  130.     Boolean            rcvUrgent;                // stream is receiving urgent data
  131.     Boolean            hasSessionOpen;            // currently open session
  132.  
  133. protected:
  134.     Ptr                macTCPStream;            // MacTCP’s reference code for this stream
  135.     Handle            itsBuffer;                    // receive buffer area
  136.     long                itsBufferSize;                // size of receive buffer
  137.  
  138.     b_16                sendNextUrgent;            // next send operation is “urgent” data
  139.     Boolean             sendNextPush;                // next send operation is “push” data
  140.  
  141.     Boolean            notifClosing;                // ASR got closing event
  142.     Boolean             remoteClose;                // ASR close due to remote host
  143.     Boolean            notifTimeout;                // ASR got ULP timeout event
  144.     Boolean             notifTerminate;                // ASR got terminate event
  145.     b_16                notifTermReason;            // ASR’s termination reason
  146.     Boolean            notifDataArrived;            // ASR got data w/ no receive
  147.     Boolean            notifUrgent;                // ASR got urgent data event
  148.     Boolean            notifICMP;                // ASR got ICMP report
  149.     ICMPReport        notifICMPreport;            // most recent ICMP report
  150.     
  151.     CCluster             *itsAsyncCalls;            // list of outstanding async calls
  152.     RcvBypassProc        itsRcvBypassProc;            // receive bypass procedure
  153.     CObject            *itsRcvBypassTarget;        // who to call from ^^^
  154.     
  155.     byte                itsULPtimeout;                // ULP timeout value in seconds
  156.     byte                itsULPaction;                // what to do on ULP timeout
  157.     byte                itsValidityFlag;                // validity bits for optional parms
  158.     byte                itsCommandTimeoutValue;        // command timeout value in seconds
  159.     byte                itsTosFlags;                // type of service flags
  160.     byte                itsPrecedence;                // precedence level
  161.     byte                itsDontFrag;                // don’t fragment flag
  162.     byte                itsTimeToLive;                // time to live
  163.     byte                itsSecurity;                // security flag
  164.     byte                itsOptionCnt;                // count of options bytes
  165.     byte                itsOptions[IPOptionStringSize];    // IP options
  166.     
  167.     Boolean             pendingOpen;                // session is being opened
  168.     Boolean             pendingClose;                // session is being closed
  169.     Boolean             pendingAbort;                // session is being aborted
  170.     Boolean            pendingNotify;                // stream is in ProcessNotify queue
  171.     Boolean             pendingDispose;                // stream is in ProcessDispose queue
  172.     Boolean             disposeOnTerminate;            // dispose stream when terminate notification comes
  173.     Boolean            receivedClose;                // received notification that session was closed or aborted
  174.     Boolean            receivedTerminate;            // terminate notification has been received
  175.     
  176.     short            itsAutoReceiveSize;            // auto-receive size (# of entries)
  177.     short            itsAutoReceiveNum;            // number of simultaneous receive calls to issue
  178.     TurboTCPQElem        qNotifyEntry;                // notification queue entry
  179.     TurboTCPQElem        qDisposeEntry;                // disposal queue entry
  180.  
  181.  
  182.     // initialize/destroy stream
  183.  
  184. public:
  185.     void ITCPStream (long recBufferSize, short autoReceiveSize, short autoReceiveNum);
  186.     virtual void Dispose (void);
  187.     virtual void OwnerDied (void);
  188.  
  189.     
  190.     // basic user TCP calls
  191.  
  192.     void OpenConnection (Boolean passive, ip_addr theRemoteIP, b_16 theRemotePort,
  193.                     b_16 theLocalPort);
  194.     void Close (void);
  195.     void Abort (void);
  196.  
  197.     void NoCopyRcv (rdsEntry *itsRDS, b_16 itsRDSSize, b_16 itsTimeOut);
  198.     void BfrReturn (Ptr itsRDS);
  199.     void Send (wdsEntry *itsWDS, b_16 itsTimeOut, Boolean disposeWDS);
  200.     void Receive (Ptr theData, b_16 itsDataSize, b_16 itsTimeOut);
  201.     void Status (TCPStatusPB *theStatusBlock);
  202.     b_16 ConnectionState (void);
  203.  
  204.  
  205.     // specialized functions for sending data
  206.  
  207.     void SendChar (char theChar);
  208.     void SendCString (char *theString);
  209.     void SendPString (ConstStr255Param theString);
  210.     void SendBfrCpy (Ptr theData, b_16 theDataSize);
  211.     void SendBfrNoCpy (Ptr theData, b_16 theDataSize, Boolean disposeWhenDone);
  212.     void SetNextPush (void);
  213.     void SetNextUrgent (Boolean useRFC793);
  214.     
  215.  
  216.     // notification routines
  217.  
  218.     virtual void HandleTCPError (OSErr theResultCode, short theCsCode);
  219.     virtual void HandleClosed (void);    
  220.     virtual void HandleClosing (Boolean remoteClosing);
  221.     virtual void HandleDataArrived (Ptr theData, b_16 theDataSize,
  222.                             Boolean isUrgent);
  223.     virtual void HandleDataSent (wdsEntry *WDSPtr);
  224.     virtual void HandleICMP (struct ICMPReport *icmpMsg);
  225.     virtual void HandleOpened (void);
  226.     virtual void HandleOpenFailed (OSErr theResultCode);
  227.     virtual void HandleSendFailed (wdsEntry *WDSPtr, OSErr theResultCode);
  228.     virtual void HandleTerminated (b_16 terminReason);
  229.     virtual void HandleTimeout (void);
  230.     virtual void HandleUnexpectedData (void);
  231.     virtual void HandleUrgentBegin (void);
  232.     
  233.     
  234.     // set configuration
  235.     
  236.     void InstallRcvBypass (CObject *whoToCall, RcvBypassProc aRcvBypassProc);
  237.         private: static void GiveBypassToAsyncCall (CObject *theObject, long param); public:
  238.     void SetULPTimeoutValue (b_16 ulpTimeoutValue);
  239.     void SetULPTimeoutAction (b_16 ulpTimeoutAction);
  240.     void SetCommandTimeout (b_16 cmdTimeoutValue);
  241.     void SetTypeOfService (b_16 newTosFlag);
  242.     void SetPrecedence (b_16 newPrecedence);
  243.     void SetDontFrag (b_16 newDontFrag);
  244.     void SetTimeToLive (b_16 newTimeToLive);
  245.     void SetSecurity (b_16 newSecurity);
  246.     void SetIPOptions (b_16 newOptionsSize, IPOptionString *newOptions);
  247.     
  248.  
  249.     // TCP urgent mode
  250.  
  251.     Boolean RcvUrgentStatus (void);
  252.     void RcvUrgentBegin (void);
  253.     void RcvUrgentMark (void);
  254.  
  255.  
  256.     // protected methods to issue TCP calls
  257.  
  258. protected:
  259.     OSErr DoAsyncCall (b_16 theCsCode, TCPiopb *theParamBlock);
  260.     OSErr DoSyncCall (b_16 theCsCode, TCPiopb *theParamBlock);
  261.  
  262.  
  263.     // auto-receive processing
  264.  
  265.     void IssueAutoReceive (void);
  266.     
  267.     
  268.     // modified collaborator mechanism
  269.     
  270.     void BroadcastSafeChange (long reason, void *info);
  271.     
  272.     
  273.     // delayed-processing routines: respond to interrupt notifications
  274.         
  275. public:
  276.     void ProcessNotify (void);
  277.     void ProcessAsyncCompletion (CTCPAsyncCall *theCall);
  278.  
  279.  
  280.     // interrupt-level methods: delay processing for non-interrupt status
  281.  
  282.     void PostponeDispose (void);
  283. protected:
  284.     void PostponeNotify (b_16 eventCode, b_16 terminReason, struct ICMPReport *icmpMsg);
  285.     static pascal void NotifyProc (StreamPtr tcpStream, unsigned short eventCode,
  286.                             Ptr userDataPtr, unsigned short terminReason,
  287.                             struct ICMPReport *icmpMsg);
  288.  
  289. };
  290.